<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> 
<html>
<head>
<title>The Swing layout management</title>
<link rel="stylesheet" href="/cfg/format.css" type="text/css">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<meta name="keywords" content="Java, Swing, layout management, layout managers, tutorial, programming, Linux">
<meta name="description" content="This part of the Java Swing tutorial covers Swing layout management.">
<meta name="language" content="en">
<meta name="author" content="Jan Bodnar">
<meta name="distribution" content="global">

<script type="text/javascript" src="/lib/jquery.js"></script>
<script type="text/javascript" src="/lib/common.js"></script>

</head>

<body>

<div class="container">

<div id="wide_ad" class="ltow">
<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* 160x600, August 2011 */
google_ad_slot = "2484182563";
google_ad_width = 160;
google_ad_height = 600;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>
</div>

<div class="content">


<a href="/" title="Home">Home</a>&nbsp;
<a href=".." title="Home">Contents</a>


<h1>The Swing layout management</h1>

<p>
The Java Swing toolkit has two kind of components. Containers and children. 
The containers group children into suitable layouts. To create layouts, 
we use <b>layout managers</b>. Layout managers are one of the most difficult 
parts of modern GUI programming. Many beginning programmers have too much 
respect for layout managers. Mainly because they are usually poorly documented.
I believe, that GUI builder's like Matisse cannot replace the proper understanding of 
layout managers. 
</p>

<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* NewSquare */
google_ad_slot = "0364418177";
google_ad_width = 300;
google_ad_height = 250;
//-->
</script> 
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> 
</script>

<p>
ZetCode offers a dedicated 196 pages <span style="color:#ff0000">e-book</span> 
for the Swing layout management process:
<br>
<a href="/ebooks/javaswinglayout/">Java Swing layout management tutorial</a> 
</p>


<h2>No manager</h2>

<p>
We can use no layout manager, if we want. There might be situations, 
where we might not need a layout manager. For example, in my code examples, 
I often go without a manager. It is because I did not want to make the examples too
complex. But to create truly portable, complex applications, we need layout managers.
</p>

<p>
Without layout manager, we position components using absolute values. 
</p>

<pre class="code">
package zetcode;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;


public class AbsoluteExample extends JFrame {


    public AbsoluteExample() {

        initUI();
    }

    public final void initUI() {

        setLayout(null);

        JButton ok = new JButton("OK");
        ok.setBounds(50, 50, 80, 25);

        JButton close = new JButton("Close");
        close.setBounds(150, 50, 80, 25);

        add(ok);
        add(close);

        setTitle("Absolute positioning");
        setSize(300, 250);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {
        
        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                AbsoluteExample ex = new AbsoluteExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>

<p>
This simple example shows two buttons. 
</p>

<pre class="explanation">
setLayout(null);
</pre>

<p>
We use absolute positioning by providing null to the 
<code>setLayout()</code> method.
</p>

<pre class="explanation">
ok.setBounds(50, 50, 80, 25);
</pre>

<p>
The <code>setBounds()</code> method positions the ok button. 
The parameters are the x, y location values and
the width and height of the component.
</p>


<h2>FlowLayout manager</h2>

<p>
This is the simplest layout manager in the Java Swing toolkit. It is 
mainly used in combination with other layout managers. When calculating 
its children size, a flow layout lets each component assume its natural 
(preferred) size.
</p>


<p>
The manager puts components into a row. In the order, they were added. 
If they do not fit into one row, they go into the next one. The components 
can be added from the right to the left or vice versa. The manager allows to align
the components. Implicitly, the components are centered and there is 5px 
space among components and components and the 
edges of the container.
</p>

<pre class="code">
FlowLayout()
FlowLayout(int align)
FlowLayout(int align, int hgap, int vgap) 
</pre>

<p>
There are three constructors available for the FlowLayout manager. The first 
one creates a manager with implicit values. Centered with 5px horizontal and vertical
spaces. The others allow to specify those parametes. 
</p>

<pre class="code">
package zetcode;

import java.awt.Dimension;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTree;
import javax.swing.SwingUtilities;


public class FlowLayoutExample extends JFrame {


    public FlowLayoutExample() {

        initUI();
    }

    public final void initUI() {

        JPanel panel = new JPanel();

        JTextArea area = new JTextArea("text area");
        area.setPreferredSize(new Dimension(100, 100));

        JButton button = new JButton("button");
        panel.add(button);

        JTree tree = new JTree();
        panel.add(tree);

        panel.add(area);

        add(panel);

        pack();

        setTitle("FlowLayout Example");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                FlowLayoutExample ex = new FlowLayoutExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>


<p>
The example shows a button, a tree and a text area component in the window. 
Interesingly, if we create an empty
tree component, there are some default values inside the component. 
</p>


<pre class="explanation">
JPanel panel = new JPanel();
</pre>

<p>
The implicit layout manager of the <code>JPanel</code> component is a 
flow layout manager. We do not have to set it manually. 
</p>

<pre class="explanation">
JTextArea area = new JTextArea("text area");
area.setPreferredSize(new Dimension(100, 100));
</pre>

<p>
The flow layout manager sets a <b>preferred</b> size for it's components. This means, 
that in our case, the area component will have 100x100 px. If we didn't set the 
preferred size, the component would have a size of its text. No more, no less. 
Without the text, the component would not be visible at all. Try to write or 
delete some text in the area component. The component will grow and shrink accordingly. 
</p>

<pre class="explanation">
panel.add(area);
</pre>

<p>
To put a component inside a container, we simply call the <code>add()</code> method.
</p>


<img src="/img/gui/javaswing/flowlayout.png" alt="FlowLaout manager">
<div class="figure">Figure: FlowLaout manager</div>


<h2>GridLayout</h2>

<p>
The <code>GridLayout</code> layout manager lays out components in a 
rectangular grid. The container is divided into equally sized rectangles. One 
component is placed in each rectangle.
</p>

<pre class="code">
package zetcode;

import java.awt.GridLayout;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;


public class GridLayoutExample extends JFrame {

    public GridLayoutExample() {

        initUI();
    }

    public final void initUI() {

        JPanel panel = new JPanel();

        panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
        panel.setLayout(new GridLayout(5, 4, 5, 5));

        String[] buttons = {
            "Cls", "Bck", "", "Close", "7", "8", "9", "/", "4",
            "5", "6", "*", "1", "2", "3", "-", "0", ".", "=", "+"
        };


        for (int i = 0; i < buttons.length; i++) {

            if (i == 2)
                panel.add(new JLabel(buttons[i]));
            else
                panel.add(new JButton(buttons[i]));
        }

        add(panel);

        setTitle("GridLayout");
        setSize(350, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                GridLayoutExample ex = new GridLayoutExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>

<p>
The example shows a skeleton of a simple calculator tool. It is an ideal 
example for this layout manager. We put 19 buttons and one label into the 
manager. Notice, that each button is of the same size. 
</p>

<pre class="explanation">
panel.setLayout(new GridLayout(5, 4, 5, 5));
</pre>

<p>
Here we set the grid layout manager for the panel component. The layout 
manager takes four parameters. The number of rows, 
the number of columns and the horizontal and vertical gaps between components. 
</p>

<img src="/img/gui/javaswing/gridlayout.png" alt="GridLayout manager">
<div class="figure">Figure: GridLayout manager</div>


<h2>BorderLayout</h2>

<p>
A <code>BorderLayout</code> manager is a very handy layout manager. 
I haven't seen it elsewhere. It divides the space into five regions. North, 
West, South, East and Centre. Each region can have only one component. 
If we need to put more components into a region, we can simply put a panel 
there with a manager of our choice. 
The components in N, W, S, E regions get their <b>preferred</b> size. The 
component in the centre takes up the whole space left.
</p>

<p>
It does not look good, if child components are too close to each other.
We must put some space among them. Each component in Swing toolkit can have 
borders around it's edges. To create a border, we either create a 
new instance of an <code>EmptyBorder</code> class or we use a 
<code>BorderFactory</code>. Except for EmptyBorder, there are 
other types of borders as well. But for layout management we will use only 
this one. 
</p>


<pre class="code">
package zetcode;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Insets;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.border.EmptyBorder;


public class BorderExample extends JFrame {


    public BorderExample() {

        initUI();
    }

    public final void initUI() {

        JPanel panel = new JPanel(new BorderLayout());
        JPanel top = new JPanel();

        top.setBackground(Color.gray);
        top.setPreferredSize(new Dimension(250, 150));
        panel.add(top);

        panel.setBorder(new EmptyBorder(new Insets(20, 20, 20, 20)));

        add(panel);

        pack();

        setTitle("Border Example");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                BorderExample ex = new BorderExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>

<p>
The example will display a gray panel and border around it.
</p>

<pre class="explanation">
JPanel panel = new JPanel(new BorderLayout());
JPanel top = new JPanel();
</pre>

<p>
We place a panel into a panel. We used a <code>BorderLayout</code> manager for the first panel, 
because this manager will resize its children.
</p>

<pre class="explanation">
panel.add(top);
</pre>

<p>
Here we placed a top panel into the panel component. More precisely, we placed 
into the center area of the <code>BorderLayout</code> manager. 
</p>

<pre class="explanation">
panel.setBorder(new EmptyBorder(new Insets(20, 20, 20, 20)));
</pre>

<p>
Here we created a 20px border around the panel. The border values are as 
follows: top, left, bottom and right. They go counterclockwise. 
</p>

<img src="/img/gui/javaswing/borderexample.png" alt="Border example">
<div class="figure">Figure: Border example</div>


<p>
The next example will show a typical usage of a border layout manager.
</p>


<pre class="code">
package zetcode;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Insets;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JTextArea;
import javax.swing.JToolBar;
import javax.swing.SwingUtilities;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;


public class BorderLayoutExample extends JFrame {


    public BorderLayoutExample() {

        initUI();
    }

    public final void initUI() {

        JMenuBar menubar = new JMenuBar();
        JMenu file = new JMenu("File");

        menubar.add(file);
        setJMenuBar(menubar);

        JToolBar toolbar = new JToolBar();
        toolbar.setFloatable(false);

        ImageIcon exit = new ImageIcon("exit.png");
        JButton bexit = new JButton(exit);
        bexit.setBorder(new EmptyBorder(0 ,0, 0, 0));
        toolbar.add(bexit);

        add(toolbar, BorderLayout.NORTH);

        JToolBar vertical = new JToolBar(JToolBar.VERTICAL);
        vertical.setFloatable(false);
        vertical.setMargin(new Insets(10, 5, 5, 5));

        ImageIcon select = new ImageIcon("drive.png");
        ImageIcon freehand = new ImageIcon("computer.png");
        ImageIcon shapeed = new ImageIcon("printer.png");

        JButton selectb = new JButton(select);
        selectb.setBorder(new EmptyBorder(3, 0, 3, 0));

        JButton freehandb = new JButton(freehand);
        freehandb.setBorder(new EmptyBorder(3, 0, 3, 0));
        JButton shapeedb = new JButton(shapeed);
        shapeedb.setBorder(new EmptyBorder(3, 0, 3, 0));

        vertical.add(selectb);
        vertical.add(freehandb);
        vertical.add(shapeedb);

        add(vertical, BorderLayout.WEST);

        add(new JTextArea(), BorderLayout.CENTER);

        JLabel statusbar = new JLabel(" Statusbar");
        statusbar.setPreferredSize(new Dimension(-1, 22));
        statusbar.setBorder(LineBorder.createGrayLineBorder());
        add(statusbar, BorderLayout.SOUTH);

        setSize(350, 300);
        setTitle("BorderLayout");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                BorderLayoutExample ex = new BorderLayoutExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>

<p>
The example shows a typical application skeleton. We show a vertical 
and horizontal toolbars, a statusbar and a central 
component. (a text area)
</p>

<p>
A default layout manager for a <code>JFrame</code> component is 
<code>BorderLayout</code> manager. So we don't have to set it.
</p>


<pre class="explanation">
add(toolbar, BorderLayout.NORTH);
</pre>

<p>
Simply put the toolbar to the north of the layout.
</p>

<pre class="explanation">
add(vertical, BorderLayout.WEST); 
</pre>

<p>
 Put the vertical toobar to the west. 
</p>

<pre class="explanation">
add(new JTextArea(), BorderLayout.CENTER);
</pre>

<p>
Put the text area to the center.
</p>

<pre class="explanation">
add(statusbar, BorderLayout.SOUTH);
</pre>

<p>
Put the statusbar to the south.
</p>


<img src="/img/gui/javaswing/borderlayout.png" alt="BorderLayout manager">
<div class="figure">Figure: BorderLayout manager</div>


<h2>BoxLayout</h2>

<p>
BoxLayout is a powerful manager, that can be used to create
sofisticated layouts. This layout manager puts components
into a row or into a column. It enables <b>nesting</b>, a 
powerful feature, that makes this manager very flexible.
It means, that we can put a box layout into another box layout. 
</p>

<p>
The box layout manager is often used with the <code>Box</code> class. 
This class creates several invisible
components, which affect the final layout. 
</p>

<ul>
<li>glue</li>
<li>strut</li>
<li>rigid area</li>
</ul>

<p>
Let's say, we want to put two buttons into the right bottom corner 
of the window. We will use the boxlayut managers to 
accomplish this.
</p>

<pre class="code">
package zetcode;

import java.awt.Dimension;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;


public class TwoButtonsExample extends JFrame {

    public TwoButtonsExample() {

        initUI();
    }

    public final void initUI() {

        JPanel basic = new JPanel();
        basic.setLayout(new BoxLayout(basic, BoxLayout.Y_AXIS));
        add(basic);

        basic.add(Box.createVerticalGlue());

        JPanel bottom = new JPanel();
        bottom.setAlignmentX(1f);
        bottom.setLayout(new BoxLayout(bottom, BoxLayout.X_AXIS));

        JButton ok = new JButton("OK");
        JButton close = new JButton("Close");

        bottom.add(ok);
        bottom.add(Box.createRigidArea(new Dimension(5, 0)));
        bottom.add(close);
        bottom.add(Box.createRigidArea(new Dimension(15, 0)));

        basic.add(bottom);
        basic.add(Box.createRigidArea(new Dimension(0, 15)));

        setTitle("Two Buttons");
        setSize(300, 150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                TwoButtonsExample ex = new TwoButtonsExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>

<p>
The following drawing illustrates the example. 
</p>

<img src="/img/gui/javaswing/twobuttons.png" alt="Two buttons">
<div class="figure">Figure: Two buttons</div>

<p>
We will create two panels. The basic panel has a vertical box layout. The 
bottom panel has a horizontal one. We will put a bottom panel into the 
basic panel. We will right align the bottom panel. The space between 
the top of the window and the bottom panel is expandable. It is done by the vertical glue.
</p>

<pre class="explanation">
basic.setLayout(new BoxLayout(basic, BoxLayout.Y_AXIS));
</pre>

<p>
Here we create a basic panel with the vertical <code>BoxLayout</code>.
</p>


<pre class="explanation">
JPanel bottom = new JPanel();
bottom.setAlignmentX(1f);
bottom.setLayout(new BoxLayout(bottom, BoxLayout.X_AXIS));
</pre>

<p>
The bottom panel is right aligned. This is done by the 
<code>setAlignmentX()</code> method. The panel has
a horizontal layout.
</p>

<pre class="explanation">
bottom.add(Box.createRigidArea(new Dimension(5, 0)));
</pre>

<p>
We put some rigid space between the buttons. 
</p>

<pre class="explanation">
basic.add(bottom);
</pre>

<p>
Here we put the bottom panel with a horizontal box layout to the 
vertical basic panel.
</p>


<pre class="explanation">
basic.add(Box.createRigidArea(new Dimension(0, 15)));
</pre>

<p>
We also put some space between the bottom panel and the border 
of the window. 
</p>


<img src="/img/gui/javaswing/twobuttons2.png" alt="Two buttons">
<div class="figure">Figure: Two buttons</div>

<p>
When we use a <code>BoxLayout</code> manager, we can set a 
rigid area among our components. 
</p>

<pre class="code">
package zetcode;

import java.awt.Dimension;

import java.awt.Insets;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.border.EmptyBorder;


public class RigidAreaExample extends JFrame {

    public RigidAreaExample() {

        initUI();
    }

    public final void initUI() {

        JPanel panel = new JPanel();
        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));

        panel.setBorder(new EmptyBorder(new Insets(40, 60, 40, 60)));

        panel.add(new JButton("Button"));
        panel.add(Box.createRigidArea(new Dimension(0, 5)));
        panel.add(new JButton("Button"));
        panel.add(Box.createRigidArea(new Dimension(0, 5)));
        panel.add(new JButton("Button"));
        panel.add(Box.createRigidArea(new Dimension(0, 5)));
        panel.add(new JButton("Button"));

        add(panel);

        pack();

        setTitle("RigidArea");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                RigidAreaExample ex = new RigidAreaExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>

<p>
In this example, we display four buttons. By default, there is no space 
among the buttons. To put some space among them, 
we add some rigid area. 
</p>


<pre class="explanation">
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
</pre>

<p>
We use a vertical <code>BoxLayout</code> manager for our panel. 
</p>

<pre class="explanation">
panel.add(new JButton("Button"));
panel.add(Box.createRigidArea(new Dimension(0, 5)));
panel.add(new JButton("Button"));
</pre>

<p>
We add buttons and create a rigid area in between them. 
</p>


<img src="/img/gui/javaswing/rigidarea.png" alt="Rigid area">
<div class="figure">Figure: Rigid area</div>


<h2>Tip of the Day</h2>

<p>
JDeveloper has a dialog window called Tip of the Day.
</p>

<img src="/img/gui/javaswing/tipofday1.png" alt="Tip of the Day">
<div class="figure">Figure: Tip of the Day</div>

<p>
We will create a similar dialog. We will use a combination of various 
layout managers. Namely a border layout, flow layout
and box layout manager.
</p>

<pre class="code">
package zetcode;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.KeyEvent;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSeparator;
import javax.swing.JTextPane;
import javax.swing.SwingUtilities;


public class TipOfDayExample extends JDialog {


    public TipOfDayExample() {

        initUI();
    }

    public final void initUI() {

        JPanel basic = new JPanel();
        basic.setLayout(new BoxLayout(basic, BoxLayout.Y_AXIS));
        add(basic);

        JPanel topPanel = new JPanel(new BorderLayout(0, 0));
        topPanel.setMaximumSize(new Dimension(450, 0));
        JLabel hint = new JLabel("JDeveloper Productivity Hints");
        hint.setBorder(BorderFactory.createEmptyBorder(0, 25, 0, 0));
        topPanel.add(hint);

        ImageIcon icon = new ImageIcon("jdev.png");
        JLabel label = new JLabel(icon);
        label.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
        topPanel.add(label, BorderLayout.EAST);

        JSeparator separator = new JSeparator();
        separator.setForeground(Color.gray);

        topPanel.add(separator, BorderLayout.SOUTH);

        basic.add(topPanel);

        JPanel textPanel = new JPanel(new BorderLayout());
        textPanel.setBorder(BorderFactory.createEmptyBorder(15, 25, 15, 25));
        JTextPane pane = new JTextPane();

        pane.setContentType("text/html");
        String text = "&lt;p&gt;&lt;b&gt;Closing windows using the mouse wheel&lt;/b&gt;&lt;/p&gt;" +
            "&lt;p&gt;Clicking with the mouse wheel on an editor tab closes the window. " +
            "This method works also with dockable windows or Log window tabs.&lt;/p&gt;";
        pane.setText(text);
        pane.setEditable(false);
        textPanel.add(pane);

        basic.add(textPanel);

        JPanel boxPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 20, 0));

        JCheckBox box = new JCheckBox("Show Tips at startup");
        box.setMnemonic(KeyEvent.VK_S);

        boxPanel.add(box);
        basic.add(boxPanel);

        JPanel bottom = new JPanel(new FlowLayout(FlowLayout.RIGHT));

        JButton ntip = new JButton("Next Tip");
        ntip.setMnemonic(KeyEvent.VK_N);
        JButton close = new JButton("Close");
        close.setMnemonic(KeyEvent.VK_C);

        bottom.add(ntip);
        bottom.add(close);
        basic.add(bottom);

        bottom.setMaximumSize(new Dimension(450, 0));

        setTitle("Tip of the Day");
        setSize(new Dimension(450, 350));
        setResizable(false);
        setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
        setLocationRelativeTo(null);
    }


    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                TipOfDayExample ex = new TipOfDayExample();
                ex.setVisible(true);
            }
        });
    }
}
</pre>

<p>
The example uses a mix of layout managers. Simply we put four panels 
into the vertically organized basic panel.
</p>

<pre class="explanation">
JPanel basic = new JPanel();
basic.setLayout(new BoxLayout(basic, BoxLayout.Y_AXIS));
add(basic);
</pre>

<p>
This is the very bottom panel. It has a vertical box layout manager. 
The basic panel is added to the default <code>JDialog</code> component. 
This component has a border layout manager by default. 
</p>


<pre class="explanation">
JPanel topPanel = new JPanel(new BorderLayout(0, 0));
</pre>

<p>
The topPanel panel has a border layout manager. We will put three 
components into it. Two labels and a separator.
</p>

<pre class="explanation">
topPanel.setMaximumSize(new Dimension(450, 0));
</pre>

<p>
If we want to have a panel, that is not greater than it's components, we 
must set it's maximum size.
The zero value is ignored. The manager calculates the necessary heights. 
</p>

<pre class="explanation">
JPanel textPanel = new JPanel(new BorderLayout());
...
textPanel.add(pane);
</pre>

<p>
The text pane component is added to the center area of the border layout manager. 
It takes all space left. Exactly, as we wanted.
</p>

<pre class="explanation">
JPanel boxPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 20, 0));
</pre>

<p>
The check box is shown in the boxPanel panel. It is left aligned. The flow 
layout manager has a 20px horizontal gap. Other components have 25px. Why is that? 
It is because the flow layout manager puts some space to between the component and 
the edge as well. 
</p>

<pre class="explanation">
JPanel bottom = new JPanel(new FlowLayout(FlowLayout.RIGHT));
...
bottom.setMaximumSize(new Dimension(450, 0));
</pre>

<p>
The bottom panel displays two buttons. It has a right aligned flow layout 
manager. In order to show the buttons on the right edge of the dialog, 
the panel must stretch horizontally from the beginning to the end.
</p>

<img src="/img/gui/javaswing/tipofday2.png" alt="Tip of the Day">
<div class="figure">Figure: Tip of the Day</div>


<p>
In this chapter, we have mentioned layout management in Swing.
</p>

<div class="center"> 
<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* horizontal */
google_ad_slot = "1734478269";
google_ad_width = 468;
google_ad_height = 60;
//-->
</script> 
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> 
</script> 
</div> 
<br>


<div class="botNav, center">
<span class="botNavItem"><a href="/">Home</a></span> ‡ <span class="botNavItem"><a href="..">Contents</a></span> ‡ 
<span class="botNavItem"><a href="#">Top of Page</a></span>
</div>


<div class="footer">
<div class="signature">
<a href="/">ZetCode</a> last modified December 25, 2010  <span class="copyright">&copy; 2007 - 2013 Jan Bodnar</span>
</div>
</div>

</div> <!-- content -->

</div> <!-- container -->

</body>
</html>

